package com.pactera.asmp.server.common.utils;

import com.pactera.asmp.server.common.constants.ResultCode;
import com.pactera.asmp.server.common.domain.Audience;
import com.pactera.asmp.server.common.exception.CustomException;
import io.jsonwebtoken.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.net.InetAddress;
import java.security.Key;
import java.util.Date;

/**
 * @ProjectName: tlsserver
 * @Package com.pactera.asmp.server.common.utils
 * @ClassName: JwtTokenUtil
 * @Description: Token工具类
 * @Date 2020/05/30 17:55
 * @Author lvzhiqiang
 * @Version 1.0
 */
public class JwtTokenUtil {
    private static Logger log = LoggerFactory.getLogger(JwtTokenUtil.class);
    public static final String AUTH_HEADER_KEY = "Authorization";
    public static final String TOKEN_PREFIX = "Bearer ";

    private JwtTokenUtil(){}
    /**
     * 解析jwt
     *
     * @param jsonWebToken
     * @param base64Security
     * @return
     */
    public static Claims parseJWT(String jsonWebToken, String base64Security) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Security))
                    .parseClaimsJws(jsonWebToken).getBody();
            return claims;
        } catch (ExpiredJwtException eje) {
            log.error("===== Token过期 =====", eje);
            throw new CustomException(ResultCode.PERMISSION_TOKEN_EXPIRED);
        } catch (Exception e) {
            log.error("===== token解析异常 =====", e);
            throw new CustomException(ResultCode.PERMISSION_TOKEN_INVALID);
        }
    }

    /**
     * createJWT  JWT = UUID + channelId + createTime + IpAddress
     *
     * @param uuid
     * @param channelId
     * @param audience
     * @return
     */
    public static String createJWT(String uuid, String roleId, int channelId, Audience audience) {
        try {
            // 使用HS256加密算法
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);
            //生成签名密钥
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(audience.base64Secret);
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
            //uuid,请求端的唯一标识码进行加密下
            //添加构成JWT的参数
            JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                    // 可以将基本不重要的对象信息放到claims
                    .claim("uuid", uuid)
                    .claim("channelId", channelId)
                    .claim("roleId", roleId)
                    .claim("createTime", nowMillis)
                    .claim("localhost", InetAddress.getLocalHost())
                    .setSubject("admin")           // 代表这个JWT的主体，即它的所有人
                    .setIssuer(audience.clientId)              // 代表这个JWT的签发主体；
                    .setIssuedAt(new Date())        // 是一个时间戳，代表这个JWT的签发时间；
                    .setAudience(audience.name)          // 代表这个JWT的接收对象；
                    .signWith(signatureAlgorithm, signingKey);
            //添加JWT Token过期时间,默认一个月，当超过一个月后需要强制重新登录不能再通过Refresh进行续期/重新连接服务器获取Token

            long ttLMillis = audience.expiresSecond *1000L;
            if (ttLMillis >= 0) {
                long expMillis = nowMillis + ttLMillis;
                Date exp = new Date(expMillis);
                builder.setExpiration(exp)  // 是一个时间戳，代表这个JWT的过期时间；
                        .setNotBefore(now); // 是一个时间戳，代表这个JWT生效的开始时间，意味着在这个时间之前验证JWT是会失败的
            }

            //生成JWT
            return builder.compact();
        } catch (Exception e) {
            log.error("签名失败", e);
            throw new CustomException(ResultCode.PERMISSION_SIGNATURE_ERROR);
        }
    }

    /**
     * getUserName
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUserName(String token, String base64Security) {
        return parseJWT(token, base64Security).getSubject();
    }

    /**
     * getUUID
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getUUID(String token, String base64Security) {
        String userId = parseJWT(token, base64Security).get("uuid", String.class);
        return Base64Util.decode(userId);
    }

    /**
     * getChannelId
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getChannelId(String token, String base64Security) {
        String userId = parseJWT(token, base64Security).get("channelId", String.class);
        return Base64Util.decode(userId);
    }

    /**
     * getRoleId
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static String getRoleId(String token, String base64Security) {
        String userId = parseJWT(token, base64Security).get("roleId", String.class);
        return Base64Util.decode(userId);
    }

    /**
     * isExpiration
     *
     * @param token
     * @param base64Security
     * @return
     */
    public static boolean isExpiration(String token, String base64Security) {
        return parseJWT(token, base64Security).getExpiration().before(new Date());
    }
}
